import request from '@/utils/request'

// 上次API调用的时间戳
let lastWorkshopCallTime = 0;

// 查询工厂列表
export function listFactory(query) {
  // 确保query是一个对象，防止undefined错误
  query = query || {};
  
  // 由于后端使用startPage()方法获取分页参数，必须以固定方式传递
  // 若依后端的startPage()使用pageNum和pageSize作为参数名称
  const pageNum = parseInt(query.pageNum) || 1;
  const pageSize = parseInt(query.pageSize) || 10;
  
  // 构建API请求参数
  const params = { ...query };
  
  // 移除可能导致问题的参数
  delete params.pageNum;
  delete params.pageSize;
  
  return request({
    url: '/ldzl-basic/factory/list',
    method: 'post',
    // 必须添加params参数，而不是放在data中，因为startPage()会从params中获取分页信息
    params: {
      pageNum: pageNum,
      pageSize: pageSize
    },
    // 业务数据保持在body中
    data: params
  })
}

// 查询车间列表
export function listWorkshop(query) {
  // 使用节流避免重复请求
  const now = Date.now();
  if (now - lastWorkshopCallTime < 500) {
    console.log("车间API调用过于频繁，跳过此次调用");
    return Promise.reject(new Error("操作过于频繁，请稍后再试"));
  }
  lastWorkshopCallTime = now;

  // 确保query是一个对象，防止undefined错误
  query = query || {};
  
  // 处理分页参数
  const pageNum = parseInt(query.pageNum) || 1;
  const pageSize = parseInt(query.pageSize) || 10;
  
  // 构建API请求参数
  const params = { ...query };
  
  // 移除可能导致问题的参数
  delete params.pageNum;
  delete params.pageSize;
  
  return request({
    url: '/ldzl-basic/wsp/list',
    method: 'post',
    params: {
      pageNum: pageNum,
      pageSize: pageSize
    },
    data: params
  })
}

// 查询生产线列表
export function listProductionLine(query) {
  // 确保query是一个对象，防止undefined错误
  query = query || {};
  
  // 处理分页参数
  const pageNum = parseInt(query.pageNum) || 1;
  const pageSize = parseInt(query.pageSize) || 10;
  
  // 构建API请求参数
  const params = { ...query };
  
  // 移除可能导致问题的参数
  delete params.pageNum;
  delete params.pageSize;
  
  return request({
    url: '/ldzl-basic/prt/list',
    method: 'post',
    params: {
      pageNum: pageNum,
      pageSize: pageSize
    },
    data: params
  })
}

// 查询工厂详细
export function getFactory(factoryId) {
  console.log("调用getFactory API，工厂ID:", factoryId);
  // 确保factoryId是有效值
  if (!factoryId) {
    console.error("工厂ID无效:", factoryId);
    return Promise.reject(new Error("工厂ID无效"));
  }
  
  // 构建查询参数 - POST请求需要一个请求体
  const data = {
    factory_id: factoryId
  };
  
  // 分页参数需要在URL参数中
  const params = {
    pageNum: 1,
    pageSize: 10
  };
  
  return request({
    url: '/ldzl-basic/factory/list',
    method: 'post',
    params: params,
    data: data  // 添加请求体数据
  }).then(response => {
    console.log("getFactory API响应:", response);
    
    // 从列表响应中提取单个工厂数据
    if (response && response.rows && response.rows.length > 0) {
      // 找到匹配的工厂
      const factory = response.rows.find(item => 
        item.factory_id == factoryId || 
        item.factoryId == factoryId);
      
      if (factory) {
        return {
          code: 200,
          data: factory
        };
      }
    }
    
    // 如果没有找到匹配的工厂，返回原始响应
    return response;
  }).catch(error => {
    console.error("getFactory API错误:", error);
    throw error;
  });
}

// 新增工厂
export function addFactory(data) {
  return request({
    url: '/ldzl-basic/factory',
    method: 'post',
    data: data
  })
}

// 修改工厂
export function updateFactory(data) {
  console.log("调用updateFactory API，数据:", data);
  
  // 确保数据对象包含必要的字段
  if (!data.factory_id) {
    console.error("工厂ID缺失");
    return Promise.reject(new Error("工厂ID缺失，无法更新"));
  }
  
  return request({
    url: '/ldzl-basic/factory',
    method: 'put',
    data: data
  }).then(response => {
    console.log("更新工厂响应:", response);
    return response;
  }).catch(error => {
    console.error("更新工厂错误:", error);
    throw error;
  });
}

// 删除工厂
export function delFactory(factoryId) {
  return request({
    url: '/ldzl-basic/factory/dp/' + factoryId,
    method: 'put'
  })
}



// 查询车间详细
export function getWorkshop(workshopId) {
  console.log("调用getFactory API，车间ID:", workshopId);
  // 确保workshopId是有效值
  if (!workshopId) {
    console.error("车间ID无效:", workshopId);
    return Promise.reject(new Error("车间ID无效"));
  }
  
  // 构建查询参数 - POST请求需要一个请求体
  const data = {
    workshop_id: workshopId
  };
  
  // 分页参数需要在URL参数中
  const params = {
    pageNum: 1,
    pageSize: 10
  };
  
  return request({
    url: '/ldzl-basic/wsp/list',
    method: 'post',
    params: params,
    data: data  // 添加请求体数据
  }).then(response => {
    console.log("getFactory API响应:", response);
    
    // 从列表响应中提取单个工厂数据
    if (response && response.rows && response.rows.length > 0) {
      // 找到匹配的工厂
      const factory = response.rows.find(item => 
        item.workshop_id == workshopId || 
        item.workshopId == workshopId);
      
      if (factory) {
        return {
          code: 200,
          data: factory
        };
      }
    }
    
    // 如果没有找到匹配的车间，返回原始响应
    return response;
  }).catch(error => {
    console.error("getFactory API错误:", error);
    throw error;
  });
}

// 新增车间
export function addWorkshop(data) {
  return request({
    url: '/ldzl-basic/wsp',
    method: 'post',
    data: data
  })
}

// 修改车间
export function updateWorkshop(data) {
  return request({
    url: '/ldzl-basic/wsp',
    method: 'put',
    data: data
  })
}

// 删除车间
export function delWorkshop(workshopId) {
  return request({
    url: '/ldzl-basic/wsp/dp/' + workshopId,
    method: 'put'
  })
}



// 查询生产线详细
export function getProductionLine(lineId) {
  console.log("调用getFactory API，生产线ID:", lineId);
  // 确保workshopId是有效值
  if (!lineId) {
    console.error("生产线ID无效:", lineId);
    return Promise.reject(new Error("生产线ID无效"));
  }
  
  // 构建查询参数 - POST请求需要一个请求体
  const data = {
    production_line_id: lineId
  };
  
  // 分页参数需要在URL参数中
  const params = {
    pageNum: 1,
    pageSize: 10
  };
  
  return request({
    url: '/ldzl-basic/prt/list',
    method: 'post',
    params: params,
    data: data  // 添加请求体数据
  }).then(response => {
    console.log("getFactory API响应:", response);
    
    // 从列表响应中提取单个工厂数据
    if (response && response.rows && response.rows.length > 0) {
      // 找到匹配的工厂
      const factory = response.rows.find(item => 
        item.production_line_id == lineId || 
        item.lineId == lineId);
      
      if (factory) {
        return {
          code: 200,
          data: factory
        };
      }
    }
    
    // 如果没有找到匹配的车间，返回原始响应
    return response;
  }).catch(error => {
    console.error("getFactory API错误:", error);
    throw error;
  });
}

// 新增生产线
export function addProductionLine(data) {
  return request({
    url: '/ldzl-basic/prt',
    method: 'post',
    data: data
  })
}

// 修改生产线
export function updateProductionLine(data) {
  return request({
    url: '/ldzl-basic/prt',
    method: 'put',
    data: data
  })
}

// 删除生产线
export function delProductionLine(lineId) {
  return request({
    url: '/ldzl-basic/prt/dp/' + lineId,
    method: 'put'
  })
}

// 查询工位列表
export function listWorkstation(query) {
  // 确保query是一个对象，防止undefined错误
  query = query || {};
  
  // 处理分页参数
  const pageNum = parseInt(query.pageNum) || 1;
  const pageSize = parseInt(query.pageSize) || 10;
  
  // 构建API请求参数
  const params = { ...query };
  
  // 移除可能导致问题的参数
  delete params.pageNum;
  delete params.pageSize;
  
  return request({
    url: '/ldzl-basic/sta/list',
    method: 'post',
    params: {
      pageNum: pageNum,
      pageSize: pageSize
    },
    data: params
  })
}

// 查询工位详细
export function getWorkstation(stationId) {
   console.log("调用getFactory API，工位ID:", stationId);
  // 确保workshopId是有效值
  if (!stationId) {
    console.error("工位ID无效:", stationId);
    return Promise.reject(new Error("工位ID无效"));
  }
  
  // 构建查询参数 - POST请求需要一个请求体
  const data = {
    station_id: stationId
  };
  
  // 分页参数需要在URL参数中
  const params = {
    pageNum: 1,
    pageSize: 10
  };
  
  return request({
    url: '/ldzl-basic/sta/list',
    method: 'post',
    params: params,
    data: data  // 添加请求体数据
  }).then(response => {
    console.log("getFactory API响应:", response);
    
    // 从列表响应中提取单个工厂数据
    if (response && response.rows && response.rows.length > 0) {
      // 找到匹配的工厂
      const factory = response.rows.find(item => 
        item.station_id == stationId || 
        item.stationId == stationId);
      
      if (factory) {
        return {
          code: 200,
          data: factory
        };
      }
    }
    
    // 如果没有找到匹配的车间，返回原始响应
    return response;
  }).catch(error => {
    console.error("getFactory API错误:", error);
    throw error;
  });
}

// 新增工位
export function addWorkstation(data) {
  return request({
    url: '/ldzl-basic/sta',
    method: 'post',
    data: data
  })
}

// 修改工位
export function updateWorkstation(data) {
  return request({
    url: '/ldzl-basic/sta',
    method: 'put',
    data: data
  })
}

// 删除工位
export function delWorkstation(stationId) {
  return request({
    url: '/ldzl-basic/sta/dp/' + stationId,
    method: 'put'
  })
}